<!DOCTYPE html>
<html>
  <head>
    <title>
      audionode-disconnect-audioparam.html
    </title>
    <script src="../../../resources/testharness.js"></script>
    <script src="../../../resources/testharnessreport.js"></script>
    <script src="../../../webaudio/resources/audit-util.js"></script>
    <script src="../../../webaudio/resources/audit.js"></script>
  </head>
  <body>
    <script id="layout-test-code">
      let renderQuantum = 128;

      let sampleRate = 44100;
      let renderDuration = 0.5;
      let disconnectTime = 0.5 * renderDuration;

      let audit = Audit.createTaskRunner();

      // Calculate the index for disconnection.
      function getDisconnectIndex(disconnectTime) {
        let disconnectIndex = disconnectTime * sampleRate;
        disconnectIndex = renderQuantum *
            Math.floor((disconnectIndex + renderQuantum - 1) / renderQuantum);
        return disconnectIndex;
      }

      // Get the index of value change.
      function getValueChangeIndex(array, targetValue) {
        return array.findIndex(function(element, index) {
          if (element === targetValue)
            return true;
        });
      }

      // Task 1: test disconnect(AudioParam) method.
      audit.define('disconnect(AudioParam)', (task, should) => {
        // Creates a buffer source with value [1] and then connect it to two
        // gain nodes in series. The output of the buffer source is lowered by
        // half
        // (* 0.5) and then connected to two |.gain| AudioParams in each gain
        // node.
        //
        //  (1) bufferSource => gain1 => gain2
        //  (2) bufferSource => half => gain1.gain
        //  (3) half => gain2.gain
        //
        // This graph should produce the output of 2.25 (= 1 * 1.5 * 1.5). After
        // disconnecting (3), it should produce 1.5.
        let context =
            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
        let source = context.createBufferSource();
        let buffer1ch = createConstantBuffer(context, 1, 1);
        let half = context.createGain();
        let gain1 = context.createGain();
        let gain2 = context.createGain();

        source.buffer = buffer1ch;
        source.loop = true;
        half.gain.value = 0.5;

        source.connect(gain1);
        gain1.connect(gain2);
        gain2.connect(context.destination);
        source.connect(half);

        // Connecting |half| to both |gain1.gain| and |gain2.gain| amplifies the
        // signal by 2.25 (= 1.5 * 1.5) because each gain node amplifies the
        // signal by 1.5 (= 1.0 + 0.5).
        half.connect(gain1.gain);
        half.connect(gain2.gain);

        source.start();

        // Schedule the disconnection at the half of render duration.
        context.suspend(disconnectTime).then(function() {
          half.disconnect(gain2.gain);
          context.resume();
        });

        context.startRendering()
            .then(function(buffer) {
              let channelData = buffer.getChannelData(0);
              let disconnectIndex = getDisconnectIndex(disconnectTime);
              let valueChangeIndex = getValueChangeIndex(channelData, 1.5);

              // Expected values are: 1 * 1.5 * 1.5 -> 1 * 1.5 = [2.25, 1.5]
              should(channelData, 'Channel #0').containValues([2.25, 1.5]);
              should(valueChangeIndex, 'The index of value change')
                  .beEqualTo(disconnectIndex);
            })
            .then(() => task.done());
      });

      // Task 2: test disconnect(AudioParam, output) method.
      audit.define('disconnect(AudioParam, output)', (task, should) => {
        // Create a 2-channel buffer source with [1, 2] in each channel and
        // make a serial connection through gain1 and gain 2. The make the
        // buffer source half with a gain node and connect it to a 2-output
        // splitter. Connect each output to 2 gain AudioParams respectively.
        //
        //    (1) bufferSource => gain1 => gain2
        //    (2) bufferSource => half => splitter(2)
        //    (3) splitter#0 => gain1.gain
        //    (4) splitter#1 => gain2.gain
        //
        // This graph should produce 3 (= 1 * 1.5 * 2) and 6 (= 2 * 1.5 * 2) for
        // each channel. After disconnecting (4), it should output 1.5 and 3.
        let context =
            new OfflineAudioContext(2, renderDuration * sampleRate, sampleRate);
        let source = context.createBufferSource();
        let buffer2ch = createConstantBuffer(context, 1, [1, 2]);
        let splitter = context.createChannelSplitter(2);
        let half = context.createGain();
        let gain1 = context.createGain();
        let gain2 = context.createGain();

        source.buffer = buffer2ch;
        source.loop = true;
        half.gain.value = 0.5;

        source.connect(gain1);
        gain1.connect(gain2);
        gain2.connect(context.destination);

        // |source| originally is [1, 2] but it becomes [0.5, 1] after 0.5 gain.
        // Each splitter's output will be applied to |gain1.gain| and
        // |gain2.gain| respectively in an additive fashion.
        source.connect(half);
        half.connect(splitter);

        // This amplifies the signal by 1.5. (= 1.0 + 0.5)
        splitter.connect(gain1.gain, 0);

        // This amplifies the signal by 2. (= 1.0 + 1.0)
        splitter.connect(gain2.gain, 1);

        source.start();

        // Schedule the disconnection at the half of render duration.
        context.suspend(disconnectTime).then(function() {
          splitter.disconnect(gain2.gain, 1);
          context.resume();
        });

        context.startRendering()
            .then(function(buffer) {
              let channelData0 = buffer.getChannelData(0);
              let channelData1 = buffer.getChannelData(1);

              let disconnectIndex = getDisconnectIndex(disconnectTime);
              let valueChangeIndexCh0 = getValueChangeIndex(channelData0, 1.5);
              let valueChangeIndexCh1 = getValueChangeIndex(channelData1, 3);

              // Expected values are: 1 * 1.5 * 2 -> 1 * 1.5 = [3, 1.5]
              should(channelData0, 'Channel #0').containValues([3, 1.5]);
              should(
                  valueChangeIndexCh0,
                  'The index of value change in channel #0')
                  .beEqualTo(disconnectIndex);

              // Expected values are: 2 * 1.5 * 2 -> 2 * 1.5 = [6, 3]
              should(channelData1, 'Channel #1').containValues([6, 3]);
              should(
                  valueChangeIndexCh1,
                  'The index of value change in channel #1')
                  .beEqualTo(disconnectIndex);
            })
            .then(() => task.done());
      });

      // Task 3: exception checks.
      audit.define('exceptions', (task, should) => {
        let context = new AudioContext();
        let gain1 = context.createGain();
        let splitter = context.createChannelSplitter(2);
        let gain2 = context.createGain();
        let gain3 = context.createGain();

        // Connect a splitter to gain nodes and merger so we can test the
        // possible ways of disconnecting the nodes to verify that appropriate
        // exceptions are thrown.
        gain1.connect(splitter);
        splitter.connect(gain2.gain, 0);
        splitter.connect(gain3.gain, 1);
        gain2.connect(gain3);
        gain3.connect(context.destination);

        // gain1 is not connected to gain3.gain. Exception should be thrown.
        should(
            function() {
              gain1.disconnect(gain3.gain);
            },
            'gain1.disconnect(gain3.gain)')
            .throw(DOMException, 'InvalidAccessError');

        // When the output index is good but the destination is invalid.
        should(
            function() {
              splitter.disconnect(gain1.gain, 1);
            },
            'splitter.disconnect(gain1.gain, 1)')
            .throw(DOMException, 'InvalidAccessError');

        // When both arguments are wrong, throw IndexSizeError first.
        should(
            function() {
              splitter.disconnect(gain1.gain, 2);
            },
            'splitter.disconnect(gain1.gain, 2)')
            .throw(DOMException, 'IndexSizeError');

        task.done();
      });

      audit.run();
    </script>
  </body>
</html>
